Back to Main Menu

Create Assessment Form from csv (Assetic Python SDK)

Introduction

The Assetic Python SDK allows a new Assessment form to be created using a csv file to define the form.

 

There are 2 aspects to the form creation:

1. Defining the fields in the form via a csv file.

2. Setting basic form attributes such as form name, description, form level etc. This step has been simplified by a script that prompts you for the required information. See the Quick Start below.

 

Refer also to the article Manage Custom Assessment Forms for additional information about assessment forms and how they are created using the Assetic application itself.

Quick Start

First create a csv file (using Excel or other editor) or Download this sample here: Download Basic Sample (FormFields.csv)

 

Download Parent Child Sample Contains parent/child comboxbox (FormFieldsParentChild.csv)

 

(Samples may open in the browser rather than downloading.  Right-click in the browser and choose the 'Save As' option)

 

Data Sample:

The following csv data sample shows a typical structure for creating an assessment form.  It is shown in a grid to make each column more obvious.

 

The column structure of this csv data is Label, Type, Attributes, Widget, Required, Hint

Operating Facility		100	Facility Detail	True	The facility name
Primary Location		100	Facility Detail	True	Main Location
System	Dropdown	1|Type A;2|Type B	System Detail	True
Classification			System Detail
Installed Area	NumericStepper	0|100|1|n0	System Detail
Complexity of Access	Dropdown	Low|Low;Medium|Medium;High|High	Facility Detail
Comment	MultiLineText	1000	System Detail		As per standard AC:3423
Is Active	Checkbox		Facility Detail
Tagged Service Date	Date		System Detail
Running Since	DateTime		System Detail		The date and time the unit was last started
Location	Map		Facility Detail

 

Some notes about the above sample:

• Only 1 column is mandatory, the "Label" column. All other columns are optional, and the order of the columns is not fixed.

• 'Facility Detail' and 'System Detail' are the labels for the 2 control groups that will contain the form fields. The form will therefore need to be created with a layout containing at least 2 control groups

• Where the form field "Type" column is empty, the default will be TextBox.

• Default values are applied if the "Attributes" cell is empty

• The format of the contents of the "Attributes" cell varies depending on the form field type

• The default value for 'Required' is False (i.e. the field is not mandatory)

Form Creation

Having created the csv file, the next step is to create the form.

Download Python Script Hint: You may need to right click and 'Save As' (Assetic.AssessmentFormCreateByPrompt.py)

 

This script will prompt you for the form details and create the form. Once the form is created you will be prompted to launch Assetic. Assetic will launch and display the new form in the Assessments Admin module.

 

Defining Parent-Child Combobox Relationships

A parent-child combobox relationship can be defined such that the selection of a value in the parent combobox results in the filtering of child combobox values.

 

To define these relationships 2 additional columns are added to the csv file. The columns are only populated for the child combobox definition row in the the csv:

• ParentLabel

  • The 'label' of the parent combox to associate the child combobx to

• ParentRelation

  • This is the relationship of the child combobox values to the parent comboxbox values and is by its nature complex to define.

  • The definition requires each child combobox value to be linked to values from the parent combobox.

    • A pair of carets ^^ to delimit each child combobox link setting

    • Within each child combobox link setting the parent combobox values are delimited by a semicolon. A pipe is used to delimit the child combobox value from the subsequent list of parent combobox values

 

The following example from the sample file FormFieldsParentChild.csv illustrates the configuration.

 

Label	Type	Attributes	ParentRelation	ParentLabel
System	Dropdown	1|Type A;2|Type B;3|All
Sub System	Dropdown	1|Sub A1;2|Sub A2;3|Sub B1;4|Sub B2	1|1;3^^2|1;3^^3|2;3^^4|2;3	System

 

Based on the above configuration the following outcome is expected:

Parent Selection	Child Selection Options
Type A	Sub A1, Sub A2
Type B	Sub B1, Sub B2
All	Sub A1, Sub A2, Sub B1, Sub B2

 

Advanced Options and Field Descriptions

The Assetic Python SDK supports form creation without having to use the script AssessmentFormCreateByPrompt.py. The following sections describe in detail the structure of the field types and how to create a form without using the script from the Quick Start section above.

1. Form Attributes

The python object assetic.AssessmentFormCreateRepresentation is used to define the form attributes required by the Assessments API.

 

The following attributes of an assessment form can be set via this representation:

Attribute Name	Description	Mandatory	Default
form_name	The name of the form to create.  Must be unique.  This will not be user visible, but this is the reference name used when using the Assetic Data Exchange API for bulk importing Assessment Form Results (Data Exchange Integration)	Yes	-
form_label	A user friendly label for the form that is shown when selecting the form in Data Exchange and advanced search	Yes	-
form_level	Defines the module that the from targets.  One of: "Asset", "GroupAsset", "ComplexAsset","Component", "ComponentServiceCriteria","NetworkEntity","SimpleAsset", "WorkOrder", "WorkRequest", "WorkTask","AssesmentsResult", "Documents", "AsmtProject", "AsmtTask", "ServiceCriteria"	Yes	-
version	A version number to assign to the form	No	1
can_add_attachment	Allows document attachments to be linked to the form.  Boolean True/False	No	True
tab_label	The label of the tab in the form	No	"Tab"
layout_pattern	Defines the pattern of the form layout.  Options include but not limited to: "Single", "column: 2 equal columns"	No	"Single"
widget_labels	For the given layout, each group of controls has a label.  This is an array. "Single" has 1 group of controls, "column: 2 equal columns" has 2 groups of controls so 2 labels are required	No	"Data"
label_formatter	Use a custom method to reformat the label as it appears in the csv file.  Examples include replacing "_" with " ", or converting upper case to 'proper case' so that the labels are more user friendly.  Useful where an external application is generating the csv file.	No	-

 

2. Form Labels - CSV file structure

A csv file is used to define the list of fields in a form.

NOTE  this file should not have a 'header' row that defines each column. The column structure is defined when executing the form creation.

 

The structure of the csv file follows a basic pattern whereby each row in the csv file represents a control in the form. A "control" is the fields in a form that data will be added to.

 

At a minimum the 'label' (user-visible label) of the control is required. The control type will default to 'TextBox' if only a list of labels is provided.

 

The controls available are:

Type	Description	Data Attributes	Default Data  Settings
TextBox	Standard single line text box	Character limit	200 character limit
MultiLineText	Text that may span multiple lines.  Use where there is a large amount of text	Character limit	1000 character limit
Dropdown	A dropdown list of items.  Can set values with user friendly descriptions	Dropdown items, values with corresponding labels	-
Date	A datetime field that allows date to be selected by a calendar popup	-	-
DateTime	A datetime field that allows date to be selected by a calendar popup and time to be selected by a time dropdown	-	-
NumericStepper	A numeric field with arrows to increase or decrease the number. The minimum value, maximum value, and value to increment the number by via the stepper may also be defined	Minimum value, Maximum value, Step value, number format	min=0, max=100, step=1, format=n0
CheckBox	A True/False style tick box	-	-
Map	A map window	-	-

 

A column in the csv file that uses the same control type names as above can be used to set the control type for each label. It is permissible to use control names that vary from the above - refer to 'Non-standard control type names' below.

 

The following attributes for a control may be defined:

Attribute Type	Description	Format	Default
Attributes	The data attributes of the control as defined in the table above per control type.  This is a single column in the csv file that used for all the different control types.  The format will therefore change per control type.	For Dropdown separate the value from the label with "|", and separate each pair of items with ";".  Optionally use a separate column for dropdown items (format is unchanged) For Numeric stepper separate min value, max value, step increment, and number format with "|".  Optionally use up to 4 separate columns in the file purely for stepper attributes ('minval", "maxval", "increment", "valueformat")   For text and multiline text  define an integer value for field length.  Optionally use a separate column in the file purely for 'Length'	As above
Hint	A 'mouse-over' hint (tooltip) to apply to the control.	Text	No hint if undefined
Required	Indicates the field is mandatory, and when viewing the form an asterisk will appear beside the label	True/False	False
Name	The reference name for the control.  Use this if integrating to another system and the name is required for integration	Text.  Cannot start with a number and should not have hyphens within the name.  Must be unique within the form	A unique id will be generated for the name
Widget	The name of the form group widget to place the control in.  Required if a layout with more than one form group widget has been defined.	Text.  Must match the name of one of the widgets from the form definition "widget_labels"	-

 

3. Non-standard control type names

If another system has created the csv file, and the control type names vary from the above list, the control type name used in the csv file can be matched to one of the examples above using the "control_types" dictionary property of the SDK AssessmentHelper module.

assesshelp = assetic.AssessmentHelper(asseticsdk.client)     assesshelp.control_types["MultiLineText"] = "Multi line Text" assesshelp.control_types["NumericStepper"] = "Numeric"

Code Sample

The following code sample is a complete sample for creating an assessment form from a csv file.  It uses the same csv data as in the sample above, except the names for the types "MultiLineText" and "NumericStepper" are different in the csv file (to illustrate how this is managed)

1. """
2. Example script to create an assessment form
3. (Assetic.AssessmentFormCreate.py)
4. Creates an assessment form in Assetic
5. """
6. import assetic
7. from assetic import Configuration
8. from assetic import ApiClient
9. from assetic import AssessmentTools
11. import re #to replace camelcase with spaced label
12. import csv #to read csv file with form definition
13. import six
14. # Assetic SDK instance.
15. asseticsdk = assetic.AsseticSDK("c:/users/you/assetic.ini",None,"Info")
17. def main():
18. fid=67
19. assesshelp = AssessmentHelper(asseticsdk.client)
21. form_repr = AssessmentFormCreateRepresentation()
22. form_repr.form_name = "ALPACA{0}".format(fid)
23. form_repr.form_label = "Alpaca Test Form {0}".format(fid)
24. form_repr.form_level = "Asset"
25. form_repr.version = 1
26. form_repr.can_add_attachment = True
27. form_repr.tab_label = "Data Tab"
28. form_repr.layout_pattern = "Single"
29. form_repr.layout_pattern = "column: 2 equal columns"
30. widget_labels = list()
31. widget_labels.append("Section 1")
32. widget_labels.append("Section 2")
33. form_repr.widget_labels = widget_labels
34. form_repr.label_formatter = None
36. assesshelp.control_types["MultiLineText"] = "Multi line Text"
37. assesshelp.control_types["NumericStepper"] = "Numeric"
39. csv_structure = None
40. csvfile = "C:/temp/HVAC fields.csv"
41. assesshelp.create_form_from_csv(form_repr,csvfile,csv_structure)
43. class AssessmentHelper(object):
44. """
45. Class to manage simplified processes for creating assessment forms
46. such
47. Uses the AssessmentTools class
48. """
50. def __init__(self, api_client=None):
51. config = Configuration()
52. if api_client:
53. self.api_client = api_client
54. else:
55. if not config.api_client:
56. config.api_client = ApiClient()
57. self.api_client = config.api_client
59. self.logger = config.packagelogger
61. self.assesstool = assetic.AssessmentTools()
62. self._control_types = self.initiate_control_types()
64. @property
65. def control_types(self):
66. """
67. dictionary of control type. The dictionary values can be changed
68. to match the source data. The corresponding keys are tested for when
69. determine which control to create
70. """
71. return self._control_types
72. @control_types.setter
73. def control_types(self,control_types):
74. self._control_types = control_types
76. def create_form_from_csv(self,form_repr,csvfile,structure=None):
77. """
78. create an assessment form from a csv file definition
79. :param form_repr: A representation containing the core form
80. creation details. AssessmentFormCreateRepresentation
81. :param csvfile: The file containing the form definition
82. :param structure: an optional mapping of row number in csv file to
83. form creation purpose. e.g row 1 = control header, row 2 = control type
84. :returns: >0=error, 0 = Success
85. """
87. form_name = form_repr.form_name
88. if form_repr.form_label == None:
89. form_label = form_repr.form_name
90. else:
91. form_label = form_repr.form_label
92. form_level = form_repr.form_level
93. version = form_repr.version
94. can_add_attachment = form_repr.can_add_attachment
95. tab_label = form_repr.tab_label
96. layout_pattern = form_repr.layout_pattern
97. widget_labels = form_repr.widget_labels
99. ##first create the form definition
100. form = self.assesstool.new_form(form_name,form_level,form_label)
101. ##create tab and widgets
102. tab = self.assesstool.add_tab_with_widgets_to_form(form,tab_label,
103. widget_labels,layout_pattern)
104. if tab == None:
105. ##error encountered
106. return 1
108. ##get the structure from csv
109. rows = self.read_csv_file_into_dict(csvfile,structure)
110. if len(rows) == 1:
111. return 1
113. ##Add the controls
114. for row in rows:
115. self.process_csv_dict_row(row,tab,widget_labels)
117. ##now create form
118. self.assesstool.create_form(form)
120. def read_csv_file_into_dict(self,filename,structure=None):
121. """
122. Read the the contents of a csv file into a representation that can be
123. used to build the controls on a form
124. :param filename: the file to read
125. :param structure: the layout mapping of the rows in the file
126. :returns: a list of the representation
127. Assetic3IntegrationRepresentationsAssessmentFormFormControlRepresentation()
128. """
129. if structure == None:
130. structure = ("Label","Type","Attributes","Widget","Required")
132. rows = list()
133. if six.PY2:
134. with open(filename, 'rt') as csvfile:
135. readCSV = csv.DictReader(
136. csvfile,fieldnames=structure,delimiter=',')
137. for row in readCSV:
138. rows.append(row)
139. else:
140. with open(filename, 'rt', encoding='utf-8', newline = '') as csvfile:
141. readCSV = csv.DictReader(csvfile,fieldnames=structure,
142. delimiter=',')
143. for row in readCSV:
144. rows.append(row)
145. return rows
148. def process_csv_dict_row(self,field_def,tab,widget_labels):
149. """
150. The field definition is from csv.DictReader.
151. Look for specific headers to determine
152. what kind of control to create and it's attributes.
153. :param field_def: the dictionary for a field
154. :param tab: the tab to add the control to
155. :param widget_labels: the widget to add the control to
156. must be in the tab
157. :returns: a list of the representation
158. Assetic3IntegrationRepresentationsAssessmentFormFormControlRepresentation()
159. """
160. label = None
161. if "Label" in field_def:
162. label = field_def["Label"]
163. else:
164. #assume first element is the label
165. label = field_def[0]
167. #check if hint for control but otherwise leave null
168. hint = None
169. if "Hint" in field_def:
170. hint = field_def["Hint"]
171. #check if name for control but otherwise leave null
172. name = None
173. if "Name" in field_def:
174. name = field_def["Name"]
176. #check if 'required' is set
177. required = None
178. if "Required" in field_def:
179. required = field_def["Required"]
181. #check if widget is defined. If not set as first label
182. widget_label = widget_labels[0]
183. if "Widget" in field_def and field_def["Widget"] in widget_labels:
184. widget_label = field_def["Widget"]
186. ##now test for type and create control
187. if "Type" not in field_def:
188. #assume text box
189. field_def["Type"] = "textbox"
190. if "Type" in field_def:
191. if field_def["Type"].lower() == \
192. self._control_types["TextBox"].lower():
193. #Standard text box
194. #get length
195. length = 200 #Default field length(will be used if undefined)
196. if "Length" in field_def:
197. length = self.get_numeric_or_default(
198. field_def["Length"],200)
199. elif "Attributes" in field_def:
200. length = self.get_numeric_or_default(
201. field_def["Attributes"],200)
202. control = self.assesstool.new_text_control(label,name,length,
203. hint=hint,required=required)
204. elif field_def["Type"].lower() == \
205. self._control_types["MultiLineText"].lower():
206. ##this is a multiline text box
207. length = 1000 #Default field length(will be used if undefined)
208. if "Length" in field_def:
209. length = self.get_numeric_or_default(
210. field_def["Length"],1000)
211. elif "Attributes" in field_def:
212. length = self.get_numeric_or_default(
213. field_def["Attributes"],1000)
214. control = self.assesstool.new_multiline_text_control(label,
215. name,length,hint=hint,required=required)
216. elif field_def["Type"].lower() == \
217. self._control_types["Dropdown"].lower():
218. ##this is a combobox (drop down list)
219. #get items
220. itemstring = None
221. if "DropdownItems" in field_def:
222. itemstring = field_def["DropdownItems"]
223. elif "Attributes" in field_def:
224. itemstring = field_def["Attributes"]
225. item_delim=";" #hardcode delimiter for the moment
226. key_value_delim="|" #hardcode delimiter for the moment
227. items = self.get_combobox_items(
228. itemstring,item_delim,key_value_delim)
229. control = self.assesstool.new_combobox_control(label,name,
230. items=items,hint=hint,required=required)
231. elif field_def["Type"].lower() == \
232. self._control_types["Date"].lower():
233. ##this is a date picker
234. control = self.assesstool.new_date_control(label,name,
235. hint=hint,required=required)
236. elif field_def["Type"].lower() == \
237. self._control_types["DateTime"].lower():
238. ##this is a date picker
239. control = self.assesstool.new_datetime_control(label,name,
240. hint=hint,required=required)
241. elif field_def["Type"].lower() == \
242. self._control_types["NumericStepper"].\
243. lower():
244. ##this is a numeric stepper
245. #get items
246. sdef = self.get_stepper_defs(field_def)
247. control = self.assesstool.new_stepper_control(label,name,
248. sdef["minval"],sdef["maxval"],sdef["increment"],
249. mask=sdef["valueformat"],hint=hint,required=required)
250. elif field_def["Type"].lower() == \
251. self._control_types["CheckBox"].lower():
252. ##this is a checkbox
253. control = self.assesstool.new_checkbox_control(label,name,
254. hint=hint,required=required)
255. elif field_def["Type"].lower() == \
256. self._control_types["Map"].lower():
257. ##this is a map control
258. control = self.assesstool.new_map_control(label,name,
259. hint=hint,required=required)
260. else:
261. ##Assume text
262. #get length
263. length = 200 #Default field length(will be used if undefined)
264. if "Length" in field_def:
265. length = self.get_numeric_or_default(
266. field_def["Length"],200)
267. elif "Attributes" in field_def:
268. length = self.get_numeric_or_default(
269. field_def["Attributes"],200)
270. control = self.assesstool.new_text_control(label,name,length,
271. hint=hint,required=required)
272. #Add the control definition to the tab
273. if control != None:
274. self.assesstool.add_control_to_tab_widget(tab,widget_label,
275. control)
277. def get_combobox_items(self,itemstring,item_delim=";",key_value_delim="|"):
278. """
279. given a string decode into a list of key/value pairs and create
280. combobox items.
281. By default key/value pairs are separated by ";"
282. By default "|" for splitting key from value
283. If only value supplied then key = value
284. :param itemstring: the string containing key/value pairs
285. :param item_delim: delimiter between each set of items (key/value pairs)
286. Default = ";"
287. :param key_value_delim:delimiter between key and value. default = "|"
288. :returns: a list of combobox item representations
289. Assetic3IntegrationRepresentationsAssessmentFormFormControlRepresentation
290. """
291. items = list()
292. if itemstring == None or itemstring.strip() == "":
293. #no lookups items defined
294. return items
296. #split into key/value pairs
297. pairs = itemstring.split(item_delim)
298. for kvp in pairs:
299. #split key and value
300. itemkvp = kvp.split(key_value_delim)
301. if len(itemkvp) == 1:
302. #only label defined. Set key to label
303. itemkvp = itemkvp + itemvkp
304. #add item representation to items list
305. items.append(self.assesstool.new_combobox_item(
306. itemkvp[1],itemkvp[0]))
307. return items
309. def get_stepper_defs(self,field_def):
310. """
311. given a form field configuration definition, test if there are settings
312. for a numeric stepper
313. :param field_def: the dictionary of settings to test
314. :returns: a dictionary of the parameters and their value
315. """
316. attributes_delim="|" #hardcode attributes delimiter for the moment
317. default_min = 0
318. default_max = 0
319. default_inc = 0
320. default_format = "n0"
321. stepperdict = dict()
322. ##apply defaults and then override if there is a setting
323. stepperdict["minval"] = default_min
324. stepperdict["maxval"] = default_max
325. stepperdict["increment"] = default_inc
326. stepperdict["valueformat"] = default_format
328. #First look for separately defined parameters
329. useatts = True #flag to indicate use of generic attributes field
330. if "MinValue" in field_def:
331. stepperdict["minval"] = field_def["MinValue"]
332. useatts = False
333. if "MaxValue" in field_def:
334. stepperdict["maxval"] = field_def["MaxValue"]
335. useatts = False
336. if "ValueIncrement" in field_def:
337. stepperdict["increment"] = field_def["ValueIncrement"]
338. useatts = False
339. if "ValueFormat" in field_def:
340. stepperdict["valueformat"] = field_def["ValueFormat"]
341. #If useatts = True set then look for delimited 'Attributes' and split
342. if useatts == True and "Attributes" in field_def and \
343. field_def["Attributes"] != None:
344. stepperdefs = field_def["Attributes"].split(attributes_delim)
345. stepperdict["minval"] = self. get_numeric_or_default(
346. stepperdefs[0],default_min)
347. if len(stepperdefs) > 1:
348. stepperdict["maxval"] = self.get_numeric_or_default(
349. stepperdefs[1],1000)
350. if len(stepperdefs) > 2:
351. stepperdict["increment"] = self.get_numeric_or_default(
352. stepperdefs[2],1)
353. if len(stepperdefs) > 3:
354. stepperdict["valueformat"] = stepperdefs[3]
356. return stepperdict
359. def get_numeric_or_default(self,value,default):
360. """
361. given a string, test if numeric and if not return default
362. :param value: the string to test
363. :param default: the default vaue.Must be a numeric (is not validated)
364. :returns: the reformatted value as a numeric
365. """
366. try:
367. numeric = value/1
368. except:
369. numeric = default
370. return numeric
372. def insert_space_in_camelcase(self,value):
373. """
374. given a string, insert a space in from of upper case characters
375. or numbers.
376. Use to make a user presentable label
377. :param value: the string to operate on
378. :returns: the reformatted string
379. """
380. return re.sub('([A-Z]{1})', r' \1',value).strip().strip("_")
382. def initiate_control_types(self):
383. """
384. initiate a dictionary of control type names with default values.
385. :returns: dictionary of supported control types
386. """
387. control_types = dict()
388. control_types["TextBox"] = "TextBox"
389. control_types["MultiLineText"] = "MultiLineText"
390. control_types["Dropdown"] = "Dropdown"
391. control_types["Date"] = "Date"
392. control_types["DateTime"] = "DateTime"
393. control_types["NumericStepper"] = "NumericStepper"
394. control_types["CheckBox"] = "CheckBox"
395. control_types["Map"] = "Map"
396. return control_types
398. class AssessmentFormCreateRepresentation(object):
399. """"
400. A structure for defining table metadata and relationships between
401. search profile names, id's and tables
402. """
403. def __init__(self,form_name=None,form_label=None,form_level=None,version=1,can_add_attachment=True,tab_label="Tab",layout_pattern="Single",widget_labels="Data",label_formatter=None):
404. """
405. AssessmentFormCreateRepresentation - a model defining the core form
406. details - form, tab, layoutpattern, control group labels
407. """
408. self.fieldtypes = {
409. "form_name": "str",
410. "form_label": "str",
411. "form_level": "str",
412. "version": "int",
413. "can_add_attachment": "bool",
414. "tab_label":"string",
415. "layout_pattern":"string",
416. "widget_labels":"list[str]",
417. "label_formatter": "string"
418. }
419. self._form_name = form_name
420. self._form_label = form_label
421. self._form_level = form_level
422. self._version = version
423. self._can_add_attachment = can_add_attachment
424. self._tab_label = tab_label
425. self._layout_pattern = layout_pattern
426. if widget_labels == None:
427. widget_labels = []
428. self._widget_labels = widget_labels
429. self._label_formatter = label_formatter
431. @property
432. def form_name(self):
433. return self._form_name
434. @form_name.setter
435. def form_name(self,form_name):
436. self._form_name = form_name
438. @property
439. def form_label(self):
440. return self._form_label
441. @form_label.setter
442. def form_label(self,form_label):
443. self._form_label = form_label
445. @property
446. def form_level(self):
447. return self._form_level
448. @form_level.setter
449. def form_level(self,form_level):
450. self._form_level = form_level
452. @property
453. def version(self):
454. return self._version
455. @version.setter
456. def version(self,version):
457. self._version = version
459. @property
460. def can_add_attachment(self):
461. return self._can_add_attachment
462. @can_add_attachment.setter
463. def can_add_attachment(self,can_add_attachment):
464. self._can_add_attachment = can_add_attachment
466. @property
467. def tab_label(self):
468. return self._tab_label
469. @tab_label.setter
470. def tab_label(self,tab_label):
471. self._tab_label = tab_label
473. @property
474. def layout_pattern(self):
475. return self._layout_pattern
476. @layout_pattern.setter
477. def layout_pattern(self,layout_pattern):
478. self._layout_pattern = layout_pattern
480. @property
481. def widget_labels(self):
482. return self._widget_labels
483. @widget_labels.setter
484. def widget_labels(self,widget_labels):
485. self._widget_labels = widget_labels
487. @property
488. def label_formatter(self):
489. return self._label_formatter
490. @label_formatter.setter
491. def label_formatter(self,label_formatter):
492. self._label_formatter = label_formatter
494. def to_dict(self):
495. """
496. Returns the model properties as a dict
497. """
498. result = {}
500. for attr, _ in six.iteritems(self.fieldtypes):
501. value = getattr(self, attr)
502. if isinstance(value, list):
503. result[attr] = list(map(
504. lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
505. value
506. ))
507. elif hasattr(value, "to_dict"):
508. result[attr] = value.to_dict()
509. elif isinstance(value, dict):
510. result[attr] = dict(map(
511. lambda item: (item[0], item[1].to_dict())
512. if hasattr(item[1], "to_dict") else item,
513. value.items()
514. ))
515. else:
516. result[attr] = value
518. return result
520. def to_str(self):
521. """
522. Returns the string representation of the model
523. """
524. return pformat(self.to_dict())
526. def __repr__(self):
527. """
528. For `print` and `pprint`
529. """
530. return self.to_str()
532. def __eq__(self, other):
533. """
534. Returns true if both objects are equal
535. """
536. return self.__dict__ == other.__dict__
538. def __ne__(self, other):
539. """
540. Returns true if both objects are not equal
541. """
542. return not self == other
545. if __name__ == "__main__":
546. main()